namespace PickGold.Charting
{
    using System;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Drawing.Imaging;
    using System.Drawing.Text;

    internal class GdiGraphics : IChartRenderingEngine
    {
        private System.Drawing.Graphics _graphics;

        public void BeginSelection(string hRef, string title)
        {
        }

        public void DrawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
        {
            this._graphics.DrawArc(pen, x, y, width, height, startAngle, sweepAngle);
        }

        public void DrawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments, float tension)
        {
            this._graphics.DrawCurve(pen, points, offset, numberOfSegments, tension);
        }

        public void DrawEllipse(Pen pen, RectangleF rect)
        {
            this._graphics.DrawEllipse(pen, rect);
        }

        public void DrawEllipse(Pen pen, float x, float y, float width, float height)
        {
            this._graphics.DrawEllipse(pen, x, y, width, height);
        }

        public void DrawImage(Image image, RectangleF rect)
        {
            this._graphics.DrawImage(image, rect);
        }

        public void DrawImage(Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr)
        {
            this._graphics.DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttr);
        }

        public void DrawImage(Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs)
        {
            this._graphics.DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttrs);
        }

        public void DrawLine(Pen pen, PointF pt1, PointF pt2)
        {
            this._graphics.DrawLine(pen, pt1, pt2);
        }

        public void DrawLine(Pen pen, float x1, float y1, float x2, float y2)
        {
            this._graphics.DrawLine(pen, x1, y1, x2, y2);
        }

        public void DrawLines(Pen pen, PointF[] points)
        {
            this._graphics.DrawLines(pen, points);
        }

        public void DrawPath(Pen pen, GraphicsPath path)
        {
            this._graphics.DrawPath(pen, path);
        }

        public void DrawPie(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
        {
            this._graphics.DrawPie(pen, x, y, width, height, startAngle, sweepAngle);
        }

        public void DrawPolygon(Pen pen, PointF[] points)
        {
            this._graphics.DrawPolygon(pen, points);
        }

        public void DrawRectangle(Pen pen, int x, int y, int width, int height)
        {
            this._graphics.DrawRectangle(pen, x, y, width, height);
        }

        public void DrawRectangle(Pen pen, float x, float y, float width, float height)
        {
            this._graphics.DrawRectangle(pen, x, y, width, height);
        }

        public void DrawString(string s, Font font, Brush brush, PointF point, StringFormat format)
        {
            this._graphics.DrawString(s, font, brush, point, format);
        }

        public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)
        {
            this._graphics.DrawString(s, font, brush, layoutRectangle, format);
        }

        public void EndSelection()
        {
        }

        public void FillEllipse(Brush brush, RectangleF rect)
        {
            this._graphics.FillEllipse(brush, rect);
        }

        public void FillPath(Brush brush, GraphicsPath path)
        {
            this._graphics.FillPath(brush, path);
        }

        public void FillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
        {
            this._graphics.FillPie(brush, x, y, width, height, startAngle, sweepAngle);
        }

        public void FillPolygon(Brush brush, PointF[] points)
        {
            this._graphics.FillPolygon(brush, points);
        }

        public void FillRectangle(Brush brush, RectangleF rect)
        {
            this._graphics.FillRectangle(brush, rect);
        }

        public void FillRectangle(Brush brush, float x, float y, float width, float height)
        {
            this._graphics.FillRectangle(brush, x, y, width, height);
        }

        public void FillRegion(Brush brush, Region region)
        {
            this._graphics.FillRegion(brush, region);
        }

        public SizeF MeasureString(string text, Font font)
        {
            return this._graphics.MeasureString(text, font);
        }

        public SizeF MeasureString(string text, Font font, SizeF layoutArea, StringFormat stringFormat)
        {
            return this._graphics.MeasureString(text, font, layoutArea, stringFormat);
        }

        public void ResetClip()
        {
            this._graphics.ResetClip();
        }

        public void Restore(GraphicsState gstate)
        {
            this._graphics.Restore(gstate);
        }

        public GraphicsState Save()
        {
            return this._graphics.Save();
        }

        public void SetClip(RectangleF rect)
        {
            this._graphics.SetClip(rect);
        }

        public void SetClip(GraphicsPath path, CombineMode combineMode)
        {
            this._graphics.SetClip(path, combineMode);
        }

        public void TranslateTransform(float dx, float dy)
        {
            this._graphics.TranslateTransform(dx, dy);
        }

        public Region Clip
        {
            get
            {
                return this._graphics.Clip;
            }
            set
            {
                this._graphics.Clip = value;
            }
        }

        public System.Drawing.Graphics Graphics
        {
            get
            {
                return this._graphics;
            }
            set
            {
                this._graphics = value;
            }
        }

        public bool IsClipEmpty
        {
            get
            {
                return this._graphics.IsClipEmpty;
            }
        }

        public System.Drawing.Drawing2D.SmoothingMode SmoothingMode
        {
            get
            {
                return this._graphics.SmoothingMode;
            }
            set
            {
                this._graphics.SmoothingMode = value;
            }
        }

        public System.Drawing.Text.TextRenderingHint TextRenderingHint
        {
            get
            {
                return this._graphics.TextRenderingHint;
            }
            set
            {
                this._graphics.TextRenderingHint = value;
            }
        }

        public Matrix Transform
        {
            get
            {
                return this._graphics.Transform;
            }
            set
            {
                this._graphics.Transform = value;
            }
        }
    }
}

